package com.c6906.vdam.das.service.impl;

import com.alibaba.fastjson.JSON;
import com.c6906.vdam.das.common.DataStatusEnum;
import com.c6906.vdam.das.common.DateUtils;
import com.c6906.vdam.das.common.IDGenUtil;
import com.c6906.vdam.das.config.redis.RedisUtils;
import com.c6906.vdam.das.dao.TerminalHistoryDetailsDAO;
import com.c6906.vdam.das.model.entity.TerminalData;
import com.c6906.vdam.das.model.entity.TerminalErrorHistoryDetails;
import com.c6906.vdam.das.model.entity.TerminalLineData;
import com.c6906.vdam.das.model.entity.TerminalWarningHistoryDetails;
import com.c6906.vdam.das.service.TerminalHistoryDetailsService;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author : TAOHUIQI @Date: 2024/7/28 12:29 @Description:
 */
@Service
public class TerminalHistoryDetailsServiceImpl implements TerminalHistoryDetailsService {

    @Resource
    TerminalHistoryDetailsDAO terminalHistoryDetailsDAO;

    @Resource
    RedisUtils redisUtils;

    @Override
    public void handleTerminalHistoryDetails(List<TerminalData> dataList) {
        // 定义一个新增异常详情addErrorDetailsList和更新异常详情updateErrorDetailsList
        // List<TerminalErrorHistoryDetails> addErrorDetailsList = new ArrayList<>();
        // List<TerminalErrorHistoryDetails> updateErrorDetailsList = new ArrayList<>();
        // 定义一个新增告警详情addWarningDetailsList和更新告警详情updateWarningDetailsList
        List<TerminalWarningHistoryDetails> addWarningDetailsList = new ArrayList<>();
        List<TerminalWarningHistoryDetails> updateWarningDetailsList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(dataList)) {
            for (TerminalData terminalData : dataList) {
                // 根据设备号从redis获取最新的两条记录
                List<String> historyList = redisUtils.getLastDatasForHistory(terminalData.getTerminalSn());
                // logger.info("getLastDatasForHistory===={}",JSON.toJSONString(historyList));
                TerminalData terminalPreData = new TerminalData();
                // 获取上一条数据
                if (historyList.size() > 1) {
                    if (!ObjectUtils.isEmpty(historyList.get(1))) {
                        // JSONString转为对象
                        terminalPreData = JSON.parseObject(historyList.get(1), TerminalData.class);
                    }
                }
                // 异常逻辑处理
                // dealWithErrorInfo(terminalData, terminalPreData, addErrorDetailsList,
                // updateErrorDetailsList);
                // 告警逻辑处理
                dealWithWarningInfo(terminalData, terminalPreData, addWarningDetailsList, updateWarningDetailsList);
            }
            // 入库处理
            // if (!CollectionUtils.isEmpty(addErrorDetailsList)) {
            // 新增异常详情
            // terminalHistoryDetailsDAO.batchInsertErrorHistoryDetails(addErrorDetailsList);
            // }
            // if (!CollectionUtils.isEmpty(updateErrorDetailsList)) {
            // 更新异常详情
            // terminalHistoryDetailsDAO.batchUpdateErrorHistoryDetails(updateErrorDetailsList);
            // }
            if (!CollectionUtils.isEmpty(addWarningDetailsList)) {
                // 新增告警详情
                terminalHistoryDetailsDAO.batchInsertWarningHistoryDetails(addWarningDetailsList);
            }
            if (!CollectionUtils.isEmpty(updateWarningDetailsList)) {
                // 更新告警详情
                terminalHistoryDetailsDAO.batchUpdateWarningHistoryDetails(updateWarningDetailsList);
            }
        }
    }

    @SuppressWarnings("unused")
    private void dealWithErrorInfo(TerminalData terminalData, TerminalData terminalPreData, List<TerminalErrorHistoryDetails> addErrorDetailsList, List<TerminalErrorHistoryDetails> updateErrorDetailsList) {
        // 异常详情表处理
        List<TerminalErrorHistoryDetails> errorHistoryList = terminalHistoryDetailsDAO.queryErrorHistoryDetailNoStopList(terminalData.getTerminalSn());
        List<TerminalErrorHistoryDetails> errorHistorys1 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.ANT_OPEN.getCode()).collect(Collectors.toList());
        List<TerminalErrorHistoryDetails> errorHistorys2 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.ANT_SHORT.getCode()).collect(Collectors.toList());
        List<TerminalErrorHistoryDetails> errorHistorys3 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.NO_VOL.getCode()).collect(Collectors.toList());

        // 异常状态判断-GNSS天线开路
        if (!terminalData.getTerminalAntOpen().equals(terminalPreData.getTerminalAntOpen())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalAntOpen().equals("0") && terminalPreData.getTerminalAntOpen().equals("1")) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(errorHistorys1)) {
                    for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys1) {
                        if (null != errorHistoryDetails) {
                            errorHistoryDetails.setErrorStopTime(terminalData.getTerminalTime());
                            // 计算异常持续时间
                            errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                            errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateErrorDetailsList.add(errorHistoryDetails);
                        }
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntOpen().equals("1") && terminalPreData.getTerminalAntOpen().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(errorHistorys1)) {
                    String antOpenId = IDGenUtil.getUUIDWithoutDash();
                    TerminalErrorHistoryDetails terminalErrorHistoryDetails2 = new TerminalErrorHistoryDetails();
                    generateAddTerminalErrorHistoryDetails(terminalData, terminalErrorHistoryDetails2, DataStatusEnum.ANT_OPEN.getCode(), DataStatusEnum.ANT_OPEN.getName(), antOpenId);
                    // 添加到新增异常详情addErrorDetailsList
                    addErrorDetailsList.add(terminalErrorHistoryDetails2);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 异常状态判断-GNSS天线短路
        if (!terminalData.getTerminalAntShort().equals(terminalPreData.getTerminalAntShort())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalAntShort().equals("0") && terminalPreData.getTerminalAntShort().equals("1")) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(errorHistorys2)) {
                    for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys2) {
                        if (null != errorHistoryDetails) {
                            errorHistoryDetails.setErrorStopTime(terminalData.getTerminalTime());
                            // 计算异常持续时间
                            errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                            errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateErrorDetailsList.add(errorHistoryDetails);
                        }
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntShort().equals("1") && terminalPreData.getTerminalAntShort().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(errorHistorys2)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalErrorHistoryDetails terminalErrorHistoryDetails2 = new TerminalErrorHistoryDetails();
                    generateAddTerminalErrorHistoryDetails(terminalData, terminalErrorHistoryDetails2, DataStatusEnum.ANT_SHORT.getCode(), DataStatusEnum.ANT_SHORT.getName(), antShortId);
                    // 添加到新增异常详情addErrorDetailsList
                    addErrorDetailsList.add(terminalErrorHistoryDetails2);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 异常状态判断-模块掉电
        if (!terminalData.getTerminalNoVol().equals(terminalPreData.getTerminalNoVol())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalNoVol().equals("0") && terminalPreData.getTerminalNoVol().equals("1")) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(errorHistorys3)) {
                    for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys3) {
                        if (null != errorHistoryDetails) {
                            errorHistoryDetails.setErrorStopTime(terminalData.getTerminalTime());
                            // 计算异常持续时间
                            errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                            errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateErrorDetailsList.add(errorHistoryDetails);
                        }
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalNoVol().equals("1") && terminalPreData.getTerminalNoVol().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(errorHistorys3)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalErrorHistoryDetails terminalErrorHistoryDetails3 = new TerminalErrorHistoryDetails();
                    generateAddTerminalErrorHistoryDetails(terminalData, terminalErrorHistoryDetails3, DataStatusEnum.NO_VOL.getCode(), DataStatusEnum.NO_VOL.getName(), antShortId);
                    // 添加到新增异常详情addErrorDetailsList
                    addErrorDetailsList.add(terminalErrorHistoryDetails3);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }
    }

    private void dealWithWarningInfo(TerminalData terminalData, TerminalData terminalPreData, List<TerminalWarningHistoryDetails> addWarningDetailsList, List<TerminalWarningHistoryDetails> updateWarningDetailsList) {
        // 告警详情表处理
        List<TerminalWarningHistoryDetails> warningHistoryList = terminalHistoryDetailsDAO.queryWarningHistoryDetailNoStopList(terminalData.getTerminalSn());
        List<TerminalWarningHistoryDetails> warningrHistorys1 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.ANT_OPEN.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys2 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.ANT_SHORT.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys3 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.NO_VOL.getCode()).collect(Collectors.toList());
        // 在线和离线单独走PushConsumer消费流程处理
        List<TerminalWarningHistoryDetails> warningHistorys5 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.OVER_SPEED.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys6 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.TIRED_DRIVE.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys7 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.GNSS_ERROR.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys8 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.UNDER_VOL.getCode()).collect(Collectors.toList());

        // 告警状态判断-GNSS天线开路
        if (!terminalData.getTerminalAntOpen().equals(terminalPreData.getTerminalAntOpen())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalAntOpen().equals("0") && terminalPreData.getTerminalAntOpen().equals("1")) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(warningrHistorys1)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningrHistorys1) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算异常持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntOpen().equals("1") && terminalPreData.getTerminalAntOpen().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningrHistorys1)) {
                    String antOpenId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails1 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails1, DataStatusEnum.ANT_OPEN.getCode(), DataStatusEnum.ANT_OPEN.getName(), antOpenId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails1);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 异常状态判断-GNSS天线短路
        if (!terminalData.getTerminalAntShort().equals(terminalPreData.getTerminalAntShort())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalAntShort().equals("0") && terminalPreData.getTerminalAntShort().equals("1")) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(warningHistorys2)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys2) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算异常持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntShort().equals("1") && terminalPreData.getTerminalAntShort().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys2)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails2 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails2, DataStatusEnum.ANT_SHORT.getCode(), DataStatusEnum.ANT_SHORT.getName(), antShortId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails2);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 异常状态判断-模块掉电
        if (!terminalData.getTerminalNoVol().equals(terminalPreData.getTerminalNoVol())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalNoVol().equals("0") && terminalPreData.getTerminalNoVol().equals("1")) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(warningHistorys3)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys3) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算异常持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalNoVol().equals("1") && terminalPreData.getTerminalNoVol().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys3)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails3 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails3, DataStatusEnum.NO_VOL.getCode(), DataStatusEnum.NO_VOL.getName(), antShortId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails3);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 告警状态判断-超速驾驶
        if (!terminalData.getTerminalOverSpeed().equals(terminalPreData.getTerminalOverSpeed())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalOverSpeed().equals("0") && terminalPreData.getTerminalOverSpeed().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys5)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys5) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalOverSpeed().equals("1") && terminalPreData.getTerminalOverSpeed().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys5)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails5 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails5, DataStatusEnum.OVER_SPEED.getCode(), DataStatusEnum.OVER_SPEED.getName(), overSpeedId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails5);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 告警状态判断-疲劳驾驶
        if (!terminalData.getTerminalTiredDrive().equals(terminalPreData.getTerminalTiredDrive())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalTiredDrive().equals("0") && terminalPreData.getTerminalTiredDrive().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys6)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys6) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalTiredDrive().equals("1") && terminalPreData.getTerminalTiredDrive().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys6)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails6 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails6, DataStatusEnum.TIRED_DRIVE.getCode(), DataStatusEnum.TIRED_DRIVE.getName(), overSpeedId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails6);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 告警状态判断-GNSS模块异常状态
        if (!terminalData.getTerminalGnssError().equals(terminalPreData.getTerminalGnssError())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalGnssError().equals("0") && terminalPreData.getTerminalGnssError().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys7)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys7) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalGnssError().equals("1") && terminalPreData.getTerminalGnssError().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys7)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails7 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails7, DataStatusEnum.GNSS_ERROR.getCode(), DataStatusEnum.GNSS_ERROR.getName(), overSpeedId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails7);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        // 告警状态判断-离线状态
        if (!terminalData.getTerminalUnderVol().equals(terminalPreData.getTerminalUnderVol())) {
            // 如果状态是1变为0
            if (terminalData.getTerminalUnderVol().equals("0") && terminalPreData.getTerminalUnderVol().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys8)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys8) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            // 计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                // 如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalUnderVol().equals("1") && terminalPreData.getTerminalUnderVol().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys8)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails8 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails8, DataStatusEnum.UNDER_VOL.getCode(), DataStatusEnum.UNDER_VOL.getName(), overSpeedId);
                    // 添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails8);
                }
                // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }
    }

    private TerminalErrorHistoryDetails generateAddTerminalErrorHistoryDetails(TerminalData terminalData, TerminalErrorHistoryDetails terminalErrorHistoryDetails, int errorType, String errorTypeName, String uuid) {
        terminalErrorHistoryDetails.setId(uuid);
        terminalErrorHistoryDetails.setTerminalSn(terminalData.getTerminalSn());
        terminalErrorHistoryDetails.setErrorStartTime(terminalData.getTerminalTime());
        terminalErrorHistoryDetails.setErrorType(errorType);
        terminalErrorHistoryDetails.setErrorTypeName(errorTypeName);
        terminalErrorHistoryDetails.setStartLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
        terminalErrorHistoryDetails.setStartLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
        terminalErrorHistoryDetails.setRegionCode(terminalData.getRegionCode());
        terminalErrorHistoryDetails.setRegionName(terminalData.getRegionName());
        terminalErrorHistoryDetails.setVehiclesCode(terminalData.getVehiclesCode());
        terminalErrorHistoryDetails.setVehPlateNum(terminalData.getVehPlateNum());
        terminalErrorHistoryDetails.setOwnUnitId(ObjectUtils.isEmpty(terminalData.getOwnUnitId()) ? 0L : Long.parseLong(terminalData.getOwnUnitId()));
        terminalErrorHistoryDetails.setOwnUnitName(terminalData.getOwnUnitName());
        terminalErrorHistoryDetails.setUseUnitId(ObjectUtils.isEmpty(terminalData.getUseUnitId()) ? 0L : Long.parseLong(terminalData.getUseUnitId()));
        terminalErrorHistoryDetails.setUseUnitName(terminalData.getUseUnitName());
        terminalErrorHistoryDetails.setPlateColorName(terminalData.getPlateColorName());
        terminalErrorHistoryDetails.setDataCreate(DateUtils.dateToStr(new Date()));
        terminalErrorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
        return terminalErrorHistoryDetails;
    }

    private TerminalErrorHistoryDetails generateAddTerminalErrorHistoryOnlineDetails(TerminalLineData terminalLineData, TerminalErrorHistoryDetails terminalErrorHistoryDetails, int errorType, String errorTypeName, String uuid) {
        terminalErrorHistoryDetails.setId(uuid);
        terminalErrorHistoryDetails.setTerminalSn(terminalLineData.getTerminalSn());
        terminalErrorHistoryDetails.setErrorStartTime(terminalLineData.getTerminalTime());
        terminalErrorHistoryDetails.setErrorType(errorType);
        terminalErrorHistoryDetails.setErrorTypeName(errorTypeName);
        terminalErrorHistoryDetails.setStartLat(DateUtils.strToBigDecimal(terminalLineData.getLatitude()));
        terminalErrorHistoryDetails.setStartLong(DateUtils.strToBigDecimal(terminalLineData.getLongitude()));
        terminalErrorHistoryDetails.setRegionCode(terminalLineData.getRegionCode());
        terminalErrorHistoryDetails.setRegionName(terminalLineData.getRegionName());
        terminalErrorHistoryDetails.setVehiclesCode(terminalLineData.getVehiclesCode());
        terminalErrorHistoryDetails.setVehPlateNum(terminalLineData.getVehPlateNum());
        terminalErrorHistoryDetails.setOwnUnitId(ObjectUtils.isEmpty(terminalLineData.getOwnUnitId()) ? 0L : Long.parseLong(terminalLineData.getOwnUnitId()));
        terminalErrorHistoryDetails.setOwnUnitName(terminalLineData.getOwnUnitName());
        terminalErrorHistoryDetails.setUseUnitId(ObjectUtils.isEmpty(terminalLineData.getUseUnitId()) ? 0L : Long.parseLong(terminalLineData.getUseUnitId()));
        terminalErrorHistoryDetails.setUseUnitName(terminalLineData.getUseUnitName());
        terminalErrorHistoryDetails.setPlateColorName(terminalLineData.getPlateColorName());
        terminalErrorHistoryDetails.setVehPropId(terminalLineData.getVehPropId());
        terminalErrorHistoryDetails.setVehPropName(terminalLineData.getVehPropName());
        terminalErrorHistoryDetails.setVehTypeId(terminalLineData.getVehTypeId());
        terminalErrorHistoryDetails.setVehTypeName(terminalLineData.getVehTypeName());
        terminalErrorHistoryDetails.setDataCreate(DateUtils.dateToStr(new Date()));
        terminalErrorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
        return terminalErrorHistoryDetails;
    }

    private TerminalWarningHistoryDetails generateAddTerminalWarningHistoryDetails(TerminalData terminalData, TerminalWarningHistoryDetails terminalWarningHistoryDetails, int warningType, String warningTypeName, String uuid) {
        terminalWarningHistoryDetails.setId(uuid);
        terminalWarningHistoryDetails.setTerminalSn(terminalData.getTerminalSn());
        terminalWarningHistoryDetails.setWarningStartTime(terminalData.getTerminalTime());
        terminalWarningHistoryDetails.setWarningType(warningType);
        terminalWarningHistoryDetails.setWarningTypeName(warningTypeName);
        terminalWarningHistoryDetails.setStartLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
        terminalWarningHistoryDetails.setStartLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
        terminalWarningHistoryDetails.setRegionCode(terminalData.getRegionCode());
        terminalWarningHistoryDetails.setRegionName(terminalData.getRegionName());
        terminalWarningHistoryDetails.setVehiclesCode(terminalData.getVehiclesCode());
        terminalWarningHistoryDetails.setVehPlateNum(terminalData.getVehPlateNum());
        terminalWarningHistoryDetails.setOwnUnitId(ObjectUtils.isEmpty(terminalData.getOwnUnitId()) ? 0L : Long.parseLong(terminalData.getOwnUnitId()));
        terminalWarningHistoryDetails.setOwnUnitName(terminalData.getOwnUnitName());
        terminalWarningHistoryDetails.setUseUnitId(ObjectUtils.isEmpty(terminalData.getUseUnitId()) ? 0L : Long.parseLong(terminalData.getUseUnitId()));
        terminalWarningHistoryDetails.setUseUnitName(terminalData.getUseUnitName());
        terminalWarningHistoryDetails.setPlateColorName(terminalData.getPlateColorName());
        terminalWarningHistoryDetails.setDataCreate(DateUtils.dateToStr(new Date()));
        terminalWarningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
        return terminalWarningHistoryDetails;
    }

    @Override
    public void handleTerminalHistoryOnlineDetails(TerminalLineData terminalLineData) {
        // 异常详情表处理
        List<TerminalErrorHistoryDetails> errorHistoryList = terminalHistoryDetailsDAO.queryErrorHistoryDetailNoStopList(terminalLineData.getTerminalSn());
        List<TerminalErrorHistoryDetails> errorHistorys4 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.OFF_LINE.getCode()).collect(Collectors.toList());

        // 异常状态判断-设备在线，离线
        if (!ObjectUtils.isEmpty(terminalLineData.getTerminalOffLine()) && terminalLineData.getTerminalOffLine().equals("0")) {
            // 如果最新的状态是在线-0
            if (!CollectionUtils.isEmpty(errorHistorys4)) {
                // 如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys4) {
                    if (null != errorHistoryDetails) {
                        errorHistoryDetails.setErrorStopTime(terminalLineData.getTerminalTime());
                        // 计算异常持续时间
                        errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                        errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(ObjectUtils.isEmpty(terminalLineData.getLatitude()) ? "0" : terminalLineData.getLatitude()));
                        errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(ObjectUtils.isEmpty(terminalLineData.getLongitude()) ? "0" : terminalLineData.getLongitude()));
                        errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                        // 更新异常详情表
                        terminalHistoryDetailsDAO.updateErrorHistoryDetails(errorHistoryDetails);
                        // logger.info("update terminal error history details success(1) status
                        // ={}",flag);
                    }
                }
                // 如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
        }
        // 如果最新的状态是在线-1
        if (!ObjectUtils.isEmpty(terminalLineData.getTerminalOffLine()) && terminalLineData.getTerminalOffLine().equals("1")) {
            // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
            if (CollectionUtils.isEmpty(errorHistorys4)) {
                String offLineId = IDGenUtil.getUUIDWithoutDash();
                TerminalErrorHistoryDetails terminalErrorHistoryDetails2 = new TerminalErrorHistoryDetails();
                generateAddTerminalErrorHistoryOnlineDetails(terminalLineData, terminalErrorHistoryDetails2, DataStatusEnum.OFF_LINE.getCode(), DataStatusEnum.OFF_LINE.getName(), offLineId);
                // 新增异常详情表
                terminalHistoryDetailsDAO.insertErrorHistoryDetails(terminalErrorHistoryDetails2);
                // logger.info("add terminal error history details success(1) status ={}",flag);
            }
            // 根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
        }
    }
}
